﻿#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

//class Test
//{
//public:
//	Test()
//	{
//		cout << "Test()" << endl;
//		a = 0;
//		b = 0;
//	}
//
//
//	~Test()
//	{
//		cout << "~Test()" << endl;;
//	}
//
//private:
//	int a;
//	int b;
//};

//class Date
//{
//public:
//	Date(int year = 2024, int month = 4, int day = 14)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	//Date(Date d)  错误写法，会造成无限循环
//	//Date(Date d) 正确写法
//	Date(const Date& d) //取引用，正确写法
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//	}
//
//	~Date()
//	{
//		_year = 0;
//		_month = 0;
//		_day = 0;
//	}
//	
//
//private:
//	//内置类型
//	int _year;
//	int _month;
//	int _day;
//
//};
//
//
//int main()
//{
//	Date d1(2025,1,1);
//	Date d2(d1);
//
//	return 0;
//}

//class Test
//{
//public:
//	Test()
//	{
//		cout << "Test()" << endl;
//		_a = 0;
//		_b = 0;
//	}
//
//	Test(const Test& t)
//	{
//		cout << "Test(const Test& t)" << endl;
//		_a = t._a;
//		_b = t._b;
//	}
//
//	~Test()
//	{
//		cout << "~Test()" << endl;;
//	}
//
//private:
//	int _a;
//	int _b;
//};
//

//class Date
//{
//public:
//	Date(int year = 2024, int month = 4, int day = 14)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	Date(const Date& d) 
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//	}
//
//	// bool operator==(Date* this, const Date& d2)
//    // 这里需要注意的是，左操作数是this，指向调用函数的对象
//	bool operator==(const Date& d)
//	{
//		return _year == d._year
//				&& _month == d._month
//				&& _day == d._day;
//	}
//
//	~Date()
//	{
//		_year = 0;
//		_month = 0;
//		_day = 0;
//	}
//
//
//private:
//	int _year;
//	int _month;
//	int _day;
//
//};
//
//int main()
//{
//	Date d1(2025, 1, 1);
//	Date d2;
//	cout << (d2 == d1) << endl;
//
//	return 0;
//}

////// 这里会发现运算符重载成全局的就需要成员变量是公有的，那么问题来了，封装性如何保证？
//// 这里其实可以用我们后面学习的友元解决，或者干脆重载成成员函数
//bool operator==(const Date &d1, const Date& d2)
//{
//	return d1._year == d2._year
//		&& d1._month == d2._month
//		&& d1._day == d2._day;
//}

//int main()
//{
//	Date d1(2025, 1, 1);
//	Date d2;
//	cout << (d2 == d1) << endl;
//
//	return 0;
//}

//// 这里会发现下面的程序会崩溃掉？这里就需要我们用深拷贝去解决。
//typedef int DataType;
//class Stack
//{
//public:
//	// 构造函数
//	Stack(size_t capacity = 10)
//	{
//		_arr = (DataType*)malloc(capacity * sizeof(DataType));
//		if (nullptr == _arr)
//		{
//			perror("malloc fail");
//			return;
//		}
//		_size = 0;
//		_capacity = capacity;
//	}
//
//	//入栈
//	void Push(const DataType& data)
//	{
//		// CheckCapacity();
//		_arr[_size] = data;
//		_size++;
//	}
//
//	// 析构函数
//	~Stack()
//	{
//		if (_arr)
//		{
//			free(_arr);
//			_arr = nullptr;
//			_capacity = 0;
//			_size = 0;
//		}
//	}
//private:
//	DataType* _arr;
//	int _size;
//	int _capacity;
//};
//int main()
//{
//	Stack s1;
//	s1.Push(1);
//	s1.Push(2);
//	s1.Push(3);
//	s1.Push(4);
//	Stack s2(s1);
//	return 0;
//}

//class Date
//{
//public:
//	Date(int year = 2024, int month = 4, int day = 14)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//
//	}
//
//	//复制运算符重载 Date对象赋值给Date对象
//	Date& operator=(const Date& d)
//	{
//		if (this != &d)
//		{
//			_year = d._year;
//			_month = d._month;
//			_day = d._day;
//		}
//		return *this;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//
//};
//
//int main()
//{
//
//
//
//	return 0;
//}

//class Date
//{
//public:
//	Date(int year = 2024, int month = 4, int day = 14)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//
//	}
//
////private:
//	int _year;
//	int _month;
//	int _day;
//
//};
//
//Date& operator=(Date& d1, const Date& d2)
//{
//	d1._year = d2._year;
//	d1._month = d2._month;
//	d1._day = d2._day;
//
//}
//
//int main()
//{
//
//	return 0;
//}

//// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
//typedef int DataType;
//class Stack
//{
//public:
//	Stack(size_t capacity = 10)
//	{
//		_array = (DataType*)malloc(capacity * sizeof(DataType));
//		if (nullptr == _array)
//		{
//			perror("malloc fail");
//			return;
//		}
//			
//		_size = 0;
//		_capacity = capacity;
//	}
//	void Push(const DataType& data)
//	{
//		// CheckCapacity();
//		_array[_size] = data;
//		_size++;
//	}
//	~Stack()
//	{
//		if (_array)
//		{
//			free(_array);
//			_array = nullptr;
//			_capacity = 0;
//			_size = 0;
//		}
//	}
//private:
//	DataType* _array;
//	size_t _size;
//	size_t _capacity;
//};
//int main()
//{
//	Stack s1;
//	s1.Push(1);
//	s1.Push(2);
//	s1.Push(3);
//	s1.Push(4);
//	Stack s2;
//	s2 = s1;
//	return 0;
//}

//class Date
//{
//public:
//	Date(int year = 2024, int month = 4, int day = 14)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	// 前置++：返回+1之后的结果
//	// 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率
//	Date& operator++()
//	{
//		_day += 1;
//		return *this;
//	}
//	// 后置++：
//	// 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载
//	// C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器
//	//自动传递
//	// 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存
//	//一份，然后给this + 1
//	//而temp是临时对象，因此只能以值的方式返回，不能返回引用
//	Date operator++(int)
//	{
//		Date temp(*this);
//		_day += 1;
//		return temp;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Date d;
//	Date d1(2024, 1, 1);
//	d = d1++; //d(2024,1,1)  d1(2024,1,2)
//	d = ++d1; //d1(2024,1,3) d(2024,1,3)
//	return 0;
//}

class Date
{
public:
	Date* operator&()
	{
		return this;
	}
	const Date* operator&()const
	{
		return this;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};